#include "ImageProcessingManagerPlugin.h"
#include "ImageProcessingWidget.h"
#include "ImageAlgorithmManager.h"
#include <QApplication>
#include <QDebug>

/**
 * @brief ImageProcessingAlgorithmManagerPlugin构造函数
 * 初始化成员变量，将UI组件和算法管理器指针设置为nullptr
 * @param parent 父对象指针
 */
ImageProcessingAlgorithmManagerPlugin::ImageProcessingAlgorithmManagerPlugin(QObject *parent) :
    CameraPluginInterface(parent),
    m_pImageProcessingWidget(nullptr),
    m_pImageAlgorithmManager(nullptr)
{
}

/**
 * @brief ImageProcessingAlgorithmManagerPlugin析构函数
 * 清理所有动态分配的资源，包括UI组件和算法管理器实例
 */
ImageProcessingAlgorithmManagerPlugin::~ImageProcessingAlgorithmManagerPlugin()
{
    // 清理UI组件
    if (m_pImageProcessingWidget) {
        m_pImageProcessingWidget = nullptr;
    }

    // 清理算法管理器
    if (m_pImageAlgorithmManager) {
        delete m_pImageAlgorithmManager;
        m_pImageAlgorithmManager = nullptr;
    }
}

/**
 * @brief 初始化插件
 * 创建图像处理UI组件、初始化算法管理器并建立所有必要的信号槽连接
 * - 创建ImageProcessingWidget并注册到相应的DockWidget中
 * - 初始化ImageAlgorithmManager并连接相关信号槽
 * - 设置初始UI状态（禁用所有算法按钮）
 */
void ImageProcessingAlgorithmManagerPlugin::initialize()
{
    // 创建并初始化图像处理UI组件
    if (!m_pImageProcessingWidget) {
        m_pImageProcessingWidget = new ImageProcessingWidget;
        emit registerWidgetToDock(DockWidgetType::ImageProcessing, m_pImageProcessingWidget);

        // 连接图像处理请求信号，从UI组件到插件处理函数
        connect(m_pImageProcessingWidget, &ImageProcessingWidget::processImageRequested,
                this, &ImageProcessingAlgorithmManagerPlugin::onProcessImageRequest);
    }

    // 创建并初始化图像算法管理器
    if (!m_pImageAlgorithmManager) {
        m_pImageAlgorithmManager = new ImageAlgorithmManager;
        // 关联算法管理器的widget就绪信号和图像processing widget的槽函数
        connect(m_pImageAlgorithmManager, &ImageAlgorithmManager::algorithmWidgetReady,
                m_pImageProcessingWidget, &ImageProcessingWidget::onAlgorithmWidgetReady);

        // 连接算法管理器的图像处理完成信号到插件的槽函数
        connect(m_pImageAlgorithmManager, &ImageAlgorithmManager::imageProcessingCompleted,
                this, &ImageProcessingAlgorithmManagerPlugin::onImageProcessingCompleted);

        // 初始化算法管理器，加载可用算法
        m_pImageAlgorithmManager->initialize();
    }

    // 将算法管理器设置为widget的属性，以便在widget中访问
    m_pImageAlgorithmManager->setProperty("algorithmManager", QVariant::fromValue<QObject*>(m_pImageAlgorithmManager));

    // 初始禁用所有算法按钮，直到用户选择图像
    m_pImageProcessingWidget->enableAllAlgorithmButtons(false);
}

/**
 * @brief 获取插件名称
 * @return 插件名称常量
 */
QString ImageProcessingAlgorithmManagerPlugin::pluginName() const
{
    return IMAGE_PROCESSING_ALGORITHM_MANAGER_PLUGIN_NAME;
}

/**
 * @brief 获取插件描述
 * @return 插件描述字符串
 */
QString ImageProcessingAlgorithmManagerPlugin::description() const
{
    return "图像算法处理管理插件，用于集成和管理各类图像处理算法";
}

/**
 * @brief 处理图像请求
 * 当用户在UI中选择特定算法时调用此函数
 * @param algorithmName 要使用的算法名称
 */
void ImageProcessingAlgorithmManagerPlugin::onProcessImageRequest(const QString& algorithmName)
{
    // 向图像管理插件发送消息，通知需要执行什么算法处理
    emit pluginMessageSent(IMAGE_PROCESSING_ALGORITHM_MANAGER_PLUGIN_NAME,
                          QString(CMD_PROCESS_IMAGE + QString(":%1")).arg(algorithmName),
                          IMAGE_MANAGEMENT_PLUGIN_NAME);
}

/**
 * @brief 更改当前选中的图像
 * 根据选中的图像更新UI状态和算法处理状态
 * @param imageGuid 新选择图像的GUID，为空表示取消选择
 */
void ImageProcessingAlgorithmManagerPlugin::changeSelectImage(const QString& imageGuid)
{
    m_pImageProcessingWidget->enableAllAlgorithmButtons(!imageGuid.isEmpty());
    m_pImageProcessingWidget->resetAllButtonsState();
    // 遍历所有已加载的算法，检查每个算法是否已应用于当前图像
    QMap<QString, ImageProcessingAlgorithmBase*> algorithms = m_pImageAlgorithmManager->algorithms();
    for (auto it = algorithms.constBegin(); it != algorithms.constEnd(); ++it)
    {
        // 调用ImageManagementPlugin的接口获取处理参数
        QVariantList getParamsArgs;
        getParamsArgs << imageGuid;
        getParamsArgs << it.key();
        QVariant paramsResult;
        bool getParamsSuccess =emit requestPluginFunctionCall(IMAGE_MANAGEMENT_PLUGIN_NAME, "isImageProcessedByAlgorithm",
                                                          getParamsArgs, paramsResult);

        // 更新UI中算法按钮的处理状态
        if (getParamsSuccess && paramsResult.isValid() && paramsResult.canConvert<bool>())
        {
            m_pImageProcessingWidget->setIsProcessed(it.key(), paramsResult.toBool());
        }
        it.value()->resetToDefaultParameters();
    }
}

/**
 * @brief 处理来自其他插件的消息
 * 主要处理图像选择和取消选择的消息
 * @param sender 发送消息的插件名称
 * @param message 消息内容
 */
void ImageProcessingAlgorithmManagerPlugin::onPluginMessage(const QString &sender, const QString &message)
{
    qDebug() << IMAGE_PROCESSING_ALGORITHM_MANAGER_PLUGIN_NAME << "from " << sender << "Message:" << message;
    
    // 处理图像被选中的消息
    if (message.startsWith(CMD_IMAGE_SELECTED":")) {
        // 解析消息，格式为：CMD_IMAGE_SELECTED:图像GUID
        QStringList parts = message.split(":");
        if (parts.size() >= 2) {
            QString imageGuid = parts[1];
            // 更新UI状态以反映选中的图像
            changeSelectImage(imageGuid);
        }
    }
    // 处理图像准备好处理的消息
    else if (message.startsWith(CMD_IMAGE_READY_FOR_PROCESSING":")) {
        // 解析消息，格式为：CMD_IMAGE_READY_FOR_PROCESSING:图像GUID:算法名称
        QStringList parts = message.split(":");
        if (parts.size() < 3)
        {
            return;
        }
        QString imageGuid = parts[1];
        QString algorithmName = parts[2];
        QString parameters;
        if(parts.size() > 3)
        {
            parameters=parts[3];
        }
        // 直接调用processSpecificImage处理图像
        processSpecificImage(imageGuid, algorithmName,parameters);
    }
    // 处理图像取消选中的消息（此消息可能来自任何插件）
    else if (message.startsWith(CMD_IMAGE_DESELECTED":")) {
        // 图像取消选中，禁用所有算法按钮
        if (m_pImageProcessingWidget) {
            m_pImageProcessingWidget->enableAllAlgorithmButtons(false);
        }
    }
}

/**
 * @brief 处理特定图像的方法（由图像管理插件调用）
 * @param imageGuid 图像的唯一标识符
 * @param algorithmName 要使用的算法名称
 * @param parameters 图像处理的参数
 * @return 处理结果，成功返回true，失败返回false
 */
QVariant ImageProcessingAlgorithmManagerPlugin::processSpecificImage(const QVariant& imageGuid, const QVariant& algorithmName,const QString& parameters)
{
    // 验证参数有效性
    if (!imageGuid.isValid() || !algorithmName.isValid()) {
        qWarning() << "Invalid imageGuid or algorithmName";
        return false;
    }

    QString guid = imageGuid.toString();
    QString algName = algorithmName.toString();

    // 优先从Image Management Plugin获取处理后图像
    QVariantList getImageArgs;
    getImageArgs << guid;
    QVariant processedImage;
    bool getProcessedImageSuccess = emit requestPluginFunctionCall(IMAGE_MANAGEMENT_PLUGIN_NAME, "getProcessedImage",
                                                                    getImageArgs, processedImage);

    QImage inputImage;
    if (getProcessedImageSuccess && processedImage.isValid() && processedImage.canConvert<QImage>() && !processedImage.value<QImage>().isNull())
    {
        inputImage = processedImage.value<QImage>();
        qDebug() << "Successfully got processed image for processing";
    }
    else
    {
        // 如果处理后图像为空，则获取原始图像
        QVariant originalImage;
        bool getOriginalImageSuccess =emit requestPluginFunctionCall(IMAGE_MANAGEMENT_PLUGIN_NAME, "getOriginalImage",
                                                                     getImageArgs, originalImage);
        if (!(getOriginalImageSuccess && originalImage.isValid() && originalImage.canConvert<QImage>()))
        {
            qWarning() << "Failed to get original image or invalid image format";
            return false;
        }
        inputImage = originalImage.value<QImage>();
    }
    
    // 获取对应的算法并执行处理
    ImageProcessingAlgorithmBase* algorithm = m_pImageAlgorithmManager->getAlgorithm(algName);
    if (!algorithm)
    {
        qWarning() << "Algorithm not found: " << algName;
        return false;
    }
    // 设置输入图像
    algorithm->setInputImage(guid, inputImage);
    // 执行图像处理
    algorithm->processImage(parameters);
    return true;
}

/**
 * @brief 处理图像处理完成信号
 * 当算法完成图像处理时被调用
 * @param imageId 处理完成的图像ID
 * @param processedImage 处理后的图像数据
 * @param algorithmName 使用的算法名称
 * @param isPretreatment 是否是预处理
 */
void ImageProcessingAlgorithmManagerPlugin::onImageProcessingCompleted(const QString& imageId, const QImage& processedImage, const QString& algorithmName,bool isPretreatment)
{
    qDebug() << "Image processing completed for image:" << imageId << "with algorithm:" << algorithmName;

    // 验证算法管理器是否已初始化
    if (!m_pImageAlgorithmManager) {
        return;
    }

    // 验证算法是否存在
    ImageProcessingAlgorithmBase* algorithm = m_pImageAlgorithmManager->getAlgorithm(algorithmName);
    if (!algorithm) {
        return;
    }

    // 获取算法处理参数
    QVariantMap processingParameters = algorithm->getProcessParameters();
    
    // 上报处理后的图像到ImageManagementPlugin
    QVariantList updateImageArgs;
    updateImageArgs << imageId;               // 图像ID
    updateImageArgs << QVariant::fromValue<QImage>(processedImage);  // 处理后的图像
    QVariant updateResult;
    //如果是预处理更新原图
    if(isPretreatment)
    {
        emit requestPluginFunctionCall(IMAGE_MANAGEMENT_PLUGIN_NAME,"updateOriginalImage",
                                       updateImageArgs,updateResult);
    }
    //否则更新处理的图像
    else
    {
        updateImageArgs << processingParameters;  // 处理参数

        bool updateSuccess = emit requestPluginFunctionCall(IMAGE_MANAGEMENT_PLUGIN_NAME,
                                                           "updateProcessedImage",
                                                           updateImageArgs,
                                                           updateResult);

        if (!updateSuccess||!updateResult.toBool())
        {
           return;
        }
        // 更新UI状态，标记该算法已应用于当前图像
        if (m_pImageProcessingWidget) {
            m_pImageProcessingWidget->setIsProcessed(algorithmName, true);
        }
    }
}

